perm filename HELP.DAT[PNT,HE]10 blob sn#549897 filedate 1980-12-10 generic text, type T, neo UTF8
COMMENT The format of this file is as follows: each entry
begins with an ∀ and ends with a ∃.  Within
each entry, the fields are separated by back slashes (\) separating
the entry number, keyword,and the data.  A formfeed is inserted
after every tenth message.  The message area begins after the symbol percent symbol.

	If you make any changes to this file, it will not be permanent.
Please do not insert any new ∀∃\ or percent signs into this file if you write it
with E.  Note also that all tabs are replaced by the right number of spaces.
	
	If this file gets messed up, a fresh copy can be generated by
executing HELP0.SAI.

%
∀\1\?\displays this information\∃

∀\2\BUGS\what to do about apparent bugs\∃

∀\3\\        If there appears to be bugs, or something does
        not work the way you think it should, a good source is this helper or
        the AL USERS' MANUAL, which you should be familiar with if
        you are running this program by yourself.
                If either of these sources do not convince you it is not a bug,
        you can log down the error and what you were doing at the time, and
        your cusswords by getting out of the helper and typing these
        things between open and close brace pairs{}.  e.g. {arm refused to move}
        This will be treated as a comment, but will be recorded in a logging
        file.
                When you are done with POINTY, send or mail MSM a message
        saying that there were bugs, and complaints were logged in the
        logging file.\∃

∀\4\\ 
                Type one of the keywords on the left column.  If you
        don't understand any of this, type HELP\∃

∀\5\HELP\help on the use of this helper\∃

∀\6\\        This helper is organized as as a directed
        graph with loops, and to each node there corresponds a message.
        Terminal nodes have no keyword associated with them, whereas
        inside nodes do.
                If the message is too long to fit on the screen,
        <formfeed> and <vert tab> may be used to scroll up and down the
        screen the way E does it.  If the message can fit in one screenful
        these will have no effect.
                At any time in the help mode, the following keywords
        are valid:
                a) The list of keywords on the left hand column of the
        screen.
                b) The list of keywords on the left hand column of the
        screen the previous time.
                c) The list of keywords on the keyword stack at the
        bottom of the screen.
 
                If you type a valid keyword, that keyword will appear
        as the last element of the keyword stack.  Since keywords
        are not repeated on the keyword stack, this means that sometimes
        the keyword stack may be trimmed back.
 
                If an invalid keyword is typed, it is as if you typed ?
        but the keyword stack will not be cut back.
 
                Note that you are now in a different mode.  Normal POINTY
        or AL commands will not work until you get out of the helper mode
        by using the DONE command.\∃

∀\7\??\ideas for other help topics\∃

∀\8\\        If there is a help topic that you think should
        be here that isnt, please send a message to MSM about it, with
        suggestions for the text of the message and at what level it should be
        invoked.\∃

∀\9\UP\goes up a level on the keyword stack\∃

∀\10\MENU\gives a list of toplevel instructions\∃

∀\11\RES\gives a list of reserved words\∃

∀\12\\These are reserved words:
        ABORT   ACOS    AFFIX   ALL     AND     ARRAY   ASIN    ATAN2   AXIS
        BAIL    BEGIN   BY
        CASE    CENTER  CLOSE   COBEGIN COEND   COMMENT CONSTRUCT       COS
        DDT     DEFINE  DELETE  DISPLAY DO      DRIVE   DUMP_VARIABLES
        ECHOOFF ECHOON  EDIT    EEDIT   END     EQV     EVAL    EVENT
        EXIT    EXP     {FCONSTRUCT}    FOR     FRAME   FUNCTION
        GATHER  GRAPH   HELP    IF      INT     INTO    INV
        LOAD_VARIABLES
        MAX     MIN     MOD     MOVE    MOVEX   MOVEY   MOVEZ
        NODISPLAY       NOUPDATE        ON      OPEN    OR      ORIENT
        PARK    POS     PRINT   PROCEDURE       PROMPT  QBAIL   QREAD
        READ    READWRIST       REDEFINE        REDISPLAY       REFERENCE
        REL     RENAME  RESETSTATUS     RESUME_MESSAGE  RETURN  RETRY   ROT
        SAVECOREIMAGE
        SCALAR  SETBASE SETSTATUS       SETSTIFF        SHOW    SIGNAL
        SIN     SQRT    STOP    STOPMESSAGE     SUBTREE
        TAN     TO      TRANS   UNFIX   UNIT    UPDATE
        VALUE   VECTOR  VTT05_OFF       VT05_ON WAIT    
        WHILE   WRIST   WRITE   WRT
        XCOORD  XOR     YCOORD  XCOORD\∃

∀\13\RESH\gives one line descriptions of the reserved words\∃

∀\14\\ABORT   stops the current action and throws you into DDT
        ACOS    arc cosine
        AFFIX   affix statement
        ALL     reserved word used with WRITE, DELETE, etc
        ARRAY   used for array declarations
        ASIN    arc sine
        ATAN2   arctangent taking two arguments
        BAIL    calls the SAIL debugger: not available in all versions
        BEGIN   denotes beginning of a block
        BY      reserved word used in MOVE, OPEN, CLOSE, AFFIX
        CASE    control statement
        CLOSE   close the hand
        COBEGIN parallel control
        COEND   indicates end of COBEGIN block
        COMMENT comment statment: non executabl statement
        CONSTRUCT       makes a trans out of three vectors
        COS     cosine function
        DDT     throws you into DDT: you better know what you are doing
        DEFINE  macro definitions
        DELETE  deletes variables
        DISPLAY displays appropriate data types
        DO      loop
        DUMP_VARIABLES  saves all the values of variables in a disk file
        DRIVE   moves individual joints
        ECHOOFF suppresses printing of input file: normal mode for QREAD
        ECHOON  prints out input file: normal mode for READ
        EDIT    edits values of variable or macro
        EEDIT   swaps to E for editing
        END     ends a block
        ≡ EQV   equivalence
        EVAL    direct evaluation
        EVENT   event declaration
        EXIT    exits from POINTY, can resume by typing CONT
        EXP     exponentiation
        FCONSTRUCT      constructs frame from 3 transes
        FOR     loop iteration
        FRAME   frame definition or declaration
        FUNCTION        no longer valid
        GATHER  to gather data
        HELP    gets the help moe
        IF      if control statement
        INT     integer part of a scalar expression
        INTO    used for COPY/MERGE
        INV     inverse trans
        LOAD_VARIABLES  reads in the variables from a dump file
        LOG     logarithm
        MAX     maximum of two expressions
        MIN     minimum of two scalar expressions
        MOD     modulus (remainder)
        MOVE    general motion statement
        MOVEX   motion in the X direction
        MOVEY   motion in the Y direction
        MOVEZ   motion in the Z direction
        NODISPLAY       shuts off the display
        NOPUDATE        does not update the display
        ON      condition monitor or used in motion statement
        OPEN    pertains to the hand opening
        ∨ OR    boolean OR operator
        ORIENT  the rotation part of a frame or trans
        PARK    parks the arm
        POS     vector part of a frame or trans
        PRINT   prints arguments on the VT05
        PROCEDURE       procedure declaration
        PROMPT  waits for user to type P at the VT05
        QBAIL   like BAIL, but takes input from QUERY.TXT on current PPN
        QREAD   like READ, but does not print on terminal what is being read
        READ    reads in the appropriate file
        READWRIST       reads the wrist
        REDEFINE        changes definition of a macro
        REDISPLAY       gets the normal table mode
        REFERENCE       type of argument used for parameter specification
        REL     relative positons
        RENAME  change the name of a variable
        RESETSTATUS     change the value of compiler parameters to 0
        RESUME_MESSAGE  the message to print out when resuming execution
        RETURN  gets out of a procedure
        RETRY   performs the motion again; valid only within error condition monitor
        ROT     the rotation operator or declaration
        SAVECOREIMAGE   saves the state of the 10 and 11
        SCALAR  used for declarations
        SETBASE assumes there is zero force on the wrist
        SETSTATUS       changes the values of compiler parameters
        SETSTIFF        sets wrist stiffness matrix
        SHOW    displays values of a list of variables
        SIGNAL  signals the event
        SIN     the sine function
        SQRT    the square root function
        STOPMESSAGE     message received from interjob mail system is ended
        TAN     tangent function
        TO      used in AFFIX,MOVE,OPEN
        TRANS   used for declaration and to make trans data type
        UNFIX   the UNFIX statement
        UNIT    computes a unit vector
        UPDATE  updates the display
        VALUE   used for declaration of procedure parameters
        VECTOR  constructing data type or declaring vectors
        VT05_OFF turns off updating of VT05
        VT05_ON turns on updating of VT05 (default)
        WAIT    used with event
        WHILE   loop
        WRIST   reads the force wrist readings
        WRITE   writes AL declarations into a file
        WRT     operator
        XCOORD  refers to x-coordinate of a vector,trans or frame
        XOR     does exclusive or
        YCOORD  refers to y-coordinate of a vector,trans or frame
        ZCOORD  refers to z-coordinate of a vector,trans or frame\∃

∀\15\DISP\describes display commands\∃

∀\16\\The display commands relate to the display on the user
        and there are several modes of display: the table display mode (the
        display you get on starting up), the type display mode, the nodisplay
        mode, and the variable display mode.
 
            NODISPLAY takes no arguments, shuts off displays
            REDISPLAY gets you back into the table display mode
            DISPLAY <type> displays all the variables of type <type>,
                where <type> may be SCALAR,VECTOR,ROT,TRANS,FRAME,
                EVENT,MACRO,PROCEDURE
            UPDATE forces immediate update of the display
            NOUPDATE prevents updating of the display
            SHOW <variable list> displays the variables in the <variable list>\∃

∀\17\ELF\gives information on the ELF, or PDP-11 interface\∃

∀\18\\        The ELF is the name given to the interface
        between the PDP-10 and PDP-11.  Before POINTY can be run successfully,
        the runtime system must be loaded and started across the ELF.  The
        ELF is a sharable device, which means that others may also use the
        interface.
                To get POINTY to work, type
 
                        R POINTY<cr>
 
                If the ELF is being used by somebody else, you may
        be able to execute the program.  However, if someone else is using the
        arms, you will not be able to run POINTY.
                If the ARM is available, it will be assigned to your job
        and the POINTY program started on the PDP-11.
        Sometimes there may be errors that cause the
        program to stop executing and enter DDT.  When that happens,
        try to find out what is wrong, and get it to continue executing,
        normally by typing either <alt>P or RETRY<alt>G if you are
        asked to do so or the interactive part on the PDP-10 will not work.
        Don't type <alt>G or you will mess up whatever you did.\∃

∀\19\VT05\describes VT05\∃

∀\20\\The VT05 is a terminal directly connected to the PDP-11.
        It prints out the status of the arm joints and limits.
        VT05_ON prints out the joint angles continuously;
        VT05_OFF shuts off the printing of joint angles on VT05
        VT05_YELLOW displays the YELLOW ARM data
        VT05_BLUE displays the BLUE ARM data\∃

∀\21\OPER\shows available operators and functions\∃

∀\22\LOGIC\gives a list of logical operators\∃

∀\23\RELAT\list of relational operators\∃

∀\24\ARITH\gives a list of arithmetic operators\∃

∀\25\FUNCT\gives a list of available functions\∃

∀\26\SCOPS\list of operations that give a scalar result\∃

∀\27\VTOPS\list of operations giving vector result\∃

∀\28\RTOPS\list of operations giving rot result\∃

∀\29\TROPS\list of operations giving trans/frame result\∃

∀\30\EXOPS\extraction functions\∃

∀\31\IMPOPS\implicit data types\∃

∀\32\\≡    EQV        equivalence \∃

∀\33\\∨    OR logical OR\∃

∀\34\\⊗    XOR        exclusive OR\∃

∀\35\\∧    AND        logical AND\∃

∀\36\\≤ < ≠ = > ≥     relational operators\∃

∀\37\\+               addition\∃

∀\38\\-               negation or difference\∃

∀\39\\.               vector dot product\∃

∀\40\\*               product\∃

∀\41\\/               division\∃

∀\42\\MAX             maximum of two operands\∃

∀\43\\MIN             minimum of two operands\∃

∀\44\\DIV             integer division quotient\∃

∀\45\\MOD             integer division remainder\∃

∀\46\\REL             vector or trans relative to frame\∃

∀\47\\WRT             vector or trans with respect to frame\∃

∀\48\\→               relative transform between two frames or transes\∃

∀\49\\↑               expoenentiation\∃

∀\50\\¬               logical not\∃

∀\51\\ORIENT          rotation part of a frame or trans\∃

∀\52\\UNIT            conversion of a vector to unit vector\∃

∀\53\\AXIS            the axis of rotation\∃

∀\54\\INV             inverse of a rot or trans\∃

∀\55\\INT             integer part of a scalar\∃

∀\56\\CONSTRUCT       constructs a frame from 3 vectors\∃

∀\57\\SQRT            square root function\∃

∀\58\\SIN COS TAN ASIN ACOS ATAN2     relevant trig functions\∃

∀\59\\LOG EXP relevant transcendental functions\∃

∀\60\\↓               downward orientation\∃

∀\61\\$               station orientation\∃

∀\62\\α               bpark orientation(???)\∃

∀\63\\{EVAL           evaluate immediate}\∃

∀\64\\|..|            magnitude of scalar or vector, or angle of rotation\∃

∀\65\\( .. )  implicit data type declaration\∃

∀\66\\FRAME VECTOR TRANS ROT  make the appropriate data type\∃

∀\67\\XCOO∀D YCOORD ZCOORD    the relevant component of the vector or trans\∃

∀\68\\The following operations return a scalar value.
        These abbreviations are used: s = scalar,v = vector,r  = rotation,
        f = frame,t = trans.
 
        s + s           scalar addition
        s - s           scalar subtraction
        s * s           scalar multiplication
        s / s           scalar division
        s ↑ s           scalar raised to a scalar power
        s MAX s         maximum
        s MIN s         minimum
        INT(s)          integer part of s
        s DIV s         integer quotient after applying INT to each argument
        s MOD s         integer remainder after applying INT to each argument
        v . v           dot product of two vectors
        |s|             absolute value of a scalar
        |v|             magnitude of vector (vector norm)
        |r|             extracts angle of rotation
        INSCALAR        reads a scalar from the console
 
        Scalar functions
        SQRT(s)         square root
        SIN(s)          sine (all trigonometric functions are in degrees)
        COS(s)          cosine
        TAN(s)          tangent
        ASIN(s)         arc-sine
        ACOS(s)         arc-cosine
        ATAN2(s,s)      arc-tangent of s/s
        LOG(s)          natural logarithm
        EXP(s)          e raised to the s power
 
        s <rel> s       returns true if relation is satisfied, else false
                        possible relations are: <,≤,=,≥,>,≠
        s ∧ s           logical and
        s ∨ s           logical or
        s ⊗ s           logical exclusive or
        s ≡ s           logical equivalence
          ¬ s           logical not
        QUERY   reads a boolean from the console\∃

∀\69\\The following operations return a scalar value.
        These abbreviations are used: s = scalar,v = vector,r  = rotation,
        f = frame,t = trans.
 
        VECTOR(s,s,s)   construct vector given (x,y,z) components
        s * v           dilation of a vector
        v / s           contraction of a vector
        v + v           vector addition
        v - v           vector subtraction
        v * v           vector cross product
        r * v           rotation of a vector
        t * v           transformation of a vector
        f * v           transformation of a vector - shorthand for (station → f) * v
        v WRT f         vector in station coordinates pointing
                        the same way as v points in f's coordinate
                        system.  v WRT f ≡ ORIENT(f)*v ≡ (f*v) - POS(f)
        UNIT(v)         vector of unit length with same direction as v
        POS(f)          vector position of frame or trans
        AXIS(r)         axis of rotation\∃

∀\70\\The following operations return a scalar value.
        These abbreviations are used: s = scalar,v = vector,r  = rotation,
        f = frame,t = trans.
 
        ROT(v,s)        constructs rotation of s degrees about v
        ORIENT(f)       orientation of a frame or trans
        r * r           composition of two rotations (the one on the right
                        is applied first)\∃

∀\71\\The following operations return a frame value.
        These abbreviations are used: s = scalar,v = vector,r  = rotation,
        f = frame,t = trans.
 
        FRAME(r,v)      constructs frame of orientation r at position v
        CONSTRUCT(v,v,v)        makes a frame: first vector gives the position,
                                second a point on the x-axis,
                                third is a point in the xy-plane
        f + v           translation of a frame
        f - v           translation of a frame
        t * f           transformation of a frame
        f * f           transformation of a frame - shorthand for (station → f) * f\∃

∀\72\\The following operations return a frame value.
        These abbreviations are used: s = scalar,v = vector,r  = rotation,
        f = frame,t = trans.
 
        TRANS(r,v)      constructs trans which will cause a rotation of r
                        followed by a translation of v
        f → f           transformation which maps from the first frame
                        to the second
        t * t           composition of two transes (the one on the right is
                        applied first)
        INV(t)          take the inverse of t\∃

∀\73\EXP\valid expressions\∃

∀\74\OPS\types of expressions\∃

∀\75\BNF\bnf definition of expressions\∃

∀\76\PRI\priority of operators\∃

∀\77\\The following are valid expressions:
        S=scalar, V=vector,R=rot,T=trans,F=frame
 
        RESULT  OPERATION
 
        S:      S+S,S-S,S*S,S/S,S↑S,LOG(S),EXP(S),INT(S),S MAX S,S MIN S,
                SIN(S),COS(S),TAN(S),ASIN(S),ACOS(S),ATAN2(S,S),
                V.V
        V:      V+V,V-V,V*V,V*S,V/S,(S,S,S),VECTOR(S,S,S)
                POS(F),POS(T)
        R:      ROT(V,S),ORIENT(F)
        F:      FRAME(R,V)
        T:      TRANS(R,V),(R,V)\∃

∀\78\\The following is the recursive definition of
        expressions in bnf form:
 
        <expression>    ::=     <befact>{{OR|XOR <befact>}}
        <befact>        ::=     <bterm>{{AND <bterm>}}
        <bterm>         ::=     <arith_exp>| <arith_exp> <rel> <arith_exp>
        <arith_exp>     ::=     {+|-} <term> {{+|- <term>}}
        <term>          ::=     <factor> {{*|/ <factor>}}
        <factor>        ::=     <pfactor>{↑ <pfactor>}
        <pfactor>       ::=     (<expression>) or |<expression>| or
                                <constant> or <id> or ¬ <pfactor> or funct or
                                funct(<expression>{{,<expression}})\∃

∀\79\\        The operators in AL generally follow
        normal precedence rules, i.e., functions are evaluated first,
        followed by exponentiations before multiplications or divisions,
        which in turn are performed before additions and subtractions.
        The order of operation can be changed by including parentheses
        at appropriate points.  In an expression where several operators
        of the same precedence occur at the same level, the operations
        are performed from left to right.
 
                functions, (), | |, NOT
                WRT → ↑
                * / . MAX MIN DIV MOD
                + -
                = ≠ < > ≤ ≥
                ∧
                ∨ ⊗
                ≡\∃

∀\80\FILE\Gives the file management commands\∃

∀\81\PHOTO\Saves the terminal session\∃

∀\82\WRITE\Saves AL declarations, macros, procedures and arrays\∃

∀\83\READ\Reads AL instructions from a disk file\∃

∀\84\LOAD\Fast loads variables saved from a file\∃

∀\85\DUMP\Dumps variables into a file\∃

∀\86\SAVE\Saves the core image\∃

∀\87\\        When you run POINTY, your terminal session
        will be logged automatically into POINTY.PHT[PNT,HE].
        If you wish to record your session
        in another file as well, the command PHOTO <filename> will save
        the terminal input into <filename>.  Once PHOTO is called, it will
        keep on recording until you make another call to PHOTO in which case
        it will stop recording in the old file and start recording
        into the new file name.
                Recording can only be done into a file that is not being
        referenced by some other user or job, and the file is written out
        every 6 lines or so, so that if you accidentally kill your job
        or the system crashes (knock on wood!) you will have a record of
        your terminal session.\∃

∀\88\\        The write command permits the state of the world
        to be saved on a disk file. The syntax is as follows:
 
                WRITE ALL|<var_list> {INTO <filename>}
 
        The instruction will write the values of all the variables,
        arrays, macros or the selected ones into the relevant file.
        If the filename is not specified, it will be written into
        the last file into which AL declarations were written.\∃

∀\89\\        File input of AL commands can be done by means of
        the READ <filename> command.  The file will be read to completion unless
        <ESCAPE> I is typed.
                Note that defaults instructions will not work from file input,
        and that statements must be separated by semicolons.\∃

∀\90\\        Fast loads variables and procedure and macro
        declarations from a file written out by the DUMP_VARIABLES command.
        The syntax is as follows:
 
                LOAD_VARIABLES <filename>
 
        This procedure can only be invoked at toplevel.\∃

∀\91\\        Dumps variable values and procedure and macro
        declarations into a file in a form readable by the LOAD_VARIABLES
        command.  The syntax is as follows:
 
                DUMP_VARIABLES <filename>
 
        This command can only be invoked at top level.\∃

∀\92\\        Saves the core image of the 10 and the 11.
        This command saves the entire state of the program in a dump file
        with extension .DMP.  The syntax is as follows:
 
                SAVECOREIMAGE <filename>
 
        Note that you will not be allowed to save a file called POINTY.DMP.
        (This is to protect against accidentally destroying the main
        core image that runs the POINTY system.)
        This will save a huge file (about 150K currently) and may easily
        send you over your disk allocation, so be sparing in its use.
        This command can only be invoked at top level.
 
                After saving the core image, the program will continue
        executing.  If you want to get this state back at a later
        time, you can do so by doing the monitor command
 
                RU <filename>\∃

∀\93\ESC_I\ESCAPE I command\∃

∀\94\\        Hitting the <ESC> key followed by an I will
        interrupt whatever the PDP-10 is doing and throw you back to the
        top level.  Any type ahead will be destroyed.  If a file is being
        read, the rest of the file will be ignored.
                This command is useful when there is some error in the
        input file which causes the generation of a large number of error
        messages, and you want to get command back to top level.
                A second place this command is useful is when
        there is some problem on the 11 and the system seems to be wedged.
        In this case it is still possible to save the values of variables
        that the PDP-10 knows about and start over.
                Typing <esc> I may not work if it is done during
        initialization, since the interrupt is not enabled at the
        end of initialization.\∃

∀\95\STATE\classes of statements\∃

∀\96\←\assignment statement\∃

∀\97\\        The assignment statement is of the form
 
                <variable> ← <expression>
        or      component(<variable>) ← <expression>
 
        where component is XCOORD,YCOORD,ZCOORD,POS or ORIENT.
        The data types on both sides of the assignment statement must
        be the same for the assignment to work, except that trans
        expressions may be assigned to frames.
 
                In the first form, if <variable> has not been declared,
        POINTY will declare it to be the same data type as the expression
        on the right hand side.  Predefined variables or constants
        like BARM, YARM, BHAND, YHAND, XHAT,YHAT,ZHAT,NILVECT may
        not have values assigned to them.
 
                The planning assignment operator ←← of AL is recognized
        and parsed, but is essentially a NOOP execpt that it serves
        to declare the variable on the left hand side if it has not
        already been declared.\∃

∀\98\MOT\list of motion commands\∃

∀\99\OPEN\opens the hand\∃

∀\100\CLOS\similar to OPEN\∃

∀\101\\        The OPEN/CLOSE command applied to
        a hand causes the hand opening to go to the desired value.
        The syntax is as follows:
 
                OPEN <hand> TO|BY <scalar_exp>
                CLOSE <hand> TO|BY <scalar_exp>
 
        permitting the use of an absolute or relative value.
        Note that OPEN bhand BY 1 is the same as CLOSE bhand BY -1.\∃

∀\102\MOVE\moves the arm\∃

∀\103\\        The MOVE command specifies the motion of
        the specified frame to the desired destination which may
        be in absolute or relative terms. The syntax is as follows:
                MOVE <frame> TO <frame1>,<frame2>,...,<framen>
                        <condition monitors>
                where n≤9.  Currently the condition monitors available are
        the FORCE and TORQUE, ERROR, DURATION, EXPRESSION, and EVENT
        condition monitors whose syntax are as follows:
                ON FORCE(direction) <rel> <scalar_exp> {IN HAND|STATION}
                        DO <statement>
                where <rel> is ≥ or < and direction is XHAT,YHAT, or ZHAT
 
                ON ERROR=<compile time constant> DO <statement>.
                ON DURATION > <scalar_exp> DO <statement>
                ON <scalar_exp> DO <statement>
                ON <event_id> DO <statement>
 
        In <statement> it is possible to ask for RETRY and the current
        motion command will be executed.  The compile time constant must
        set certain bits, and may be abbreviated by means of the following
        macros which are already predefined:
                DEFINE PANIC_BUTTON=⊂ 1024⊃;    { = '2000 }
                DEFINE EXCESSIVE_FORCE=⊂ 2048⊃; { ='4000  }
                DEFINE TIME_OUT=⊂ 4096⊃;        { ='10000 }
 
                Clauses available are the DURATION, STIFFNESS, WRIST
        ZEROED/NOT ZEROED, WOBBLE, SPEED_FACTOR, FORCE_FRAME
        with the following syntax:
 
                WITH DURATION=n         where n is a compile time constant
                WITH STIFFNESS = (<vect>,<vect>,<trans>) 
                WITH STIFFNESS = (<vect>,<vect>) AT <trans>
                WITH WRIST ZEROED
                WITH WRIST NOT ZEROED
                WITH WOBBLE=n           where n is a compile time constant
                WITH SPEED_FACTOR = n   where n is a compile time constant
                WITH FORCE_FRAME = <trans> {IN HAND|STATION}\∃

∀\104\CENTER\does a grasp\∃

∀\105\\        The CENTER command does adaptive grasping.
        The syntax is as follows:
 
                CENTER <arm>\∃

∀\106\GATH\gathers force and torque data\∃

∀\107\\        The GATHER command is used for collecting
        force data during the next motion.  You should put in as many
        components as you are interested in.  The syntax is as follows:
 
                GATHER(c1,c2,...,cn)
 
        where c1,c2,..cn are components and may be any of the terms
        FX,FY,FZ,MX,MY,MZ,T1,T2,T3,T4,T5,T6,TBL.  The first six represent
        forces and torques in the principal directions.  If TBL is specified,
        the quantities are in table coordinates, otherwise in hand coordinates.
        T1 thru T6 represent forces measured according to joints.
 
                The gather command sets up the preparatory commands
        for the next motion command, and after the next interaction
        with the runtime system which involves a motion, the data
        will be read back into POINTY and be available to be examined by
        the GRAPH command.\∃

∀\108\DECL\declaration statement\∃

∀\109\\        Declarations may be made explicitly as
        in the case of AL, or implicitly by means of assignment statements.
        Explicit declarations may be made by means of the following
        syntactical construct:
 
                <data_type> <variable list>
        where <data_type> is one of SCALAR, VECTOR, ROT, TRANS, FRAME or
        EVENT.  <variable list> consists of a series of identifiers
        separated by commas.
 
                Arrays may be declared by including ARRAY after the data type,
        e.g.
                SCALAR ARRAY S[1:10,3:5]
 
        The indices may be constants or scalar expressions.  Scalar
        arrays will be initialized to 0, vector arrays to nilvect,
        rot arrays to nilrot, trans and frame arrays to niltrans.
 
                Macros are declared by means of the DEFINE statement,
        while procedures declarations are described in detail elsewhere.\∃

∀\110\CONT\list of control statements\∃

∀\111\IF\IF statement\∃

∀\112\\        The IF statement has the following syntax:
 
                IF <scalar exp> THEN <statement>
        or      IF <scalar exp> THEN <statement> ELSE <statement>
 
                The IF statement cannot be used as an expression.\∃

∀\113\FOR\FOR statement\∃

∀\114\\        The FOR statement has the following syntax:
 
                FOR <scalar> ← <scal exp> STEP <scal exp> UNTIL <scal exp>
                        DO <statement>\∃

∀\115\DO\DO statement\∃

∀\116\\        The DO statement has the following syntax:
 
                DO <statement> UNTIL <condition>
 
        <statement> will be executed until <condition> becomes TRUE\∃

∀\117\WHILE\WHILE statement\∃

∀\118\\        The WHILE statement has the following syntax:
 
                WHILE <cond> DO <statement>
 
        <cond> is a scalar expression, and is checked.  If it is TRUE( non zero)
        <statement> is executed and the <cond> checked and <statement>
        executed and the sequence repeated until <cond> becomes FALSE(0).\∃

∀\119\OTHERS\these are some of the other AL instructions\∃

∀\120\COMM\this describes use of COMMENTS\∃

∀\121\\        There are two forms of comment statements.
        The first form is having the reserved word COMMENT followed
        by anything and ended by a semicolon.  The second
        form is enclosing the comment between open and close brace pairs
        e.g. {this is a comment} which may appear anywhere.  Note that
        the delimiters may be nested.\∃

∀\122\NON_AL\these non AL instructions facilitate interaction\∃

∀\123\EDIT\permits the changing of the value of simple variables\∃

∀\124\\        The EDIT command displays the values of
        variables to be displayed in the line editor
        and permits the user to change their values.  The syntax of the
        command is as follows:
 
                        EDIT <variable name>
 
        where <variable name> is the name of the appropriate variable to be
        changed.  Currently only scalars, vectors, transes, rots or frames
        variables which are not arrays may be edited.  Macros may also be
        edited by means of this command.
                The EDIT command argument is sticky, i.e. if a variable
        name is not given, it will assume that it is the last variable that
        was edited.\∃

∀\125\EEDIT\writes the macro in a file and swaps to E\∃

∀\126\\        The EEDIT command takes a macro name
        as argument and writes it out into a disk file.  The core image
        is then saved, and the program swaps to E where the user is
        permitted to make changes to the macro body.  This is particularly
        useful when the macro body is a long one and many changes need
        to be made to it.  Minor changes may be made by means of the
        EDIT command.
                When you are satisfied with the macro, type <control>X RUN
        and you will get back to POINTY.  In the meantime please make sure
        not to change the state of the program on the PDP-11.\∃

∀\127\DEL\deletes some or all variables\∃

∀\128\\        The DELETE command deletes all the user
        defined variables or some of them.  The syntax is as follows:
 
                        DELETE ALL
                        DELETE <variable list>
 
                In the first form, all user declared variables are
        deleted after asking for confirmation. In the second form
        POINTY will complain if some of the variables in the list are
        non existent.  In the second form, frame arrays may not be
        deleted.  Also, individual elements of an array may not
        be deleted.
 
                A more liberal form of the instruction is executed
        if DELETE is replaced by QDELETE.  In the first form, confirmation
        is not asked for, while in the second form, POINTY does not
        complain if the name in the variable list is non existent\∃

∀\129\GRAPH\explains the GRAPH command\∃

∀\130\\        The syntax of the graph command is simply
        GRAPH.  This command gets you into the module which helps to
        plot and save force data on a disk file or display on a data disc.
        This command is valid only after a GATHER and move.  On exiting
        the GRAPH module, the data is destroyed in order to reclaim the
        space which the data occupies for some other purpose.\∃

∀\131\SETS\explains the SETSTATUS and RESETSTATUS commands\∃

∀\132\\        The SETSTATUS and RESETSTATUS commands
        are used to set compiler variables.  The syntax is as follows:
                SETSTATUS(<var>,<value>)
                RESETSTATUS(<var>,<value>)
        If <value> is left out, it defaults to 1 in the case of SETSTATUS
        and 0 in the case of RESETSTATUS.  <var> currently may be the
        following:
 
                NOELF   - no output to the ELF
                NOFOLD  - no constant folding and evaluation of constant
                          scalars and reals
                LINE    - prints out the expanded version of the last
                          statement on the terminal
                PPCODE  - the pcode of the statement being parsed will
                          printed out at the terminal
                PWCODE  - the pcode of the statement being parsed will be
                          appended to the file PPCODE.FOO
                ALPRIN  - subsequent printout of variables in AL format
                          rather than POINTY format
                PRTIME  - prints the execution time for the current
                          instruction\∃

∀\133\ERROR\talks about how to handle errors\∃

∀\134\NOARM\what to do if there is no arm action\∃

∀\135\\        When the arm does not do what you expect
        it to do, namely move, there will probably be a message printed
        out at the VT05 console which may explain the error.
                One of the commonest forms of errors is that the power
        supply is off or one of the brake switches is off.  For the
        former, turn on the arm motor power by hitting the big red
        button on the underside of one of the short sides of the table.
                Sometimes the arm seems to move in weird fashions,
        or will claim that it cannot move to the PARK position!
        When this happens, it may be that the arm is not properly
        initialised.  In this case, just reload and start the system
        again.
                There are two forms of recovery.  RETRY<alt>G at the
        VT05 will try to repeat the motion, while <alt>P will go on
        with the next instruction.  DO NOT ever type <alt>G during execution
        of POINTY since this will throw the synchronization out, unless
        you know what you are doing.\∃

∀\136\PARSE\explanation of error messages\∃

∀\137\\        POINTY is based on the assumption
        that it will be used interactively, and any errors encountered
        during parsing a statement results in abandoning any further
        processing and giving control back to the user.
                This may cause grief if move commands
        and errors occur in a disk file instead of in the terminal
        input mode.
                It also means that if you are trying to write
        a long program interactively you better not make any typing
        mistakes, or you will have to start over.
                It is much easier to build up programs as macros
        and to edit the macros if they do not behave as you think they
        should.  When you are happy with the macros, declare a procedure
        with the appropriate macro as body.\∃

∀\138\SYNTAX\syntax of statements\∃

∀\139\\        WRITE ALL INTO <filename>
        WRITE <variable list> INTO <filename>
        WRITE INTO <filename>
        READ <filename>
        QREAD <filename>
        LOAD_VARIABLES <filename>
        DUMP_VARIABLES <filename>
        SAVECOREIMAGE <filename>\∃

∀\140\\        REDISPLAY
        NODISPLAY
        DISPLAY <SCALAR|VECTOR|ROT|TRANS|FRAME|EVENT>
        SHOW <variable list>
        VT05_ON
        VT05_OFF\∃

∀\141\\        SCALAR s1,s2,s3,.....
        VECTOR v1,v2,v3,...
        ROT r1,r2,r3,...
        TRANS t1,t2,t3,...
        FRAME f1,f2,f3,...
        EVENT e1,e2,e3,...
        <SCALAR|VECTOR|ROT|TRANS|FRAME|EVENT> ARRAY a[l1:u1,l2:u2,...ln:un]\∃

∀\142\DONE\quits help mode\∃

∀\143\DEBUG\details of the high level debugger\∃

∀\144\\ 
        DOCUMENTATION OF THE DEBUGGING FACILITIES IN POINTY
        ---------------------------------------------------
 
        To set POINTY in debug mode the instruction
                SETSTATUS(DEBUG)  or 
                DEBUGON
        are required. You can reset POINTY to the normal mode by typing
                RESETSTATUS(DEBUG) or 
                DEBUGOFF
 
        When in  debug mode  POINTY will  stop at  the beginning  of any  compound
        statement you type  in, while  it doesn't  stop if  you  type in a  simple
        statement.
 
        When in debug mode  POINTY reads general POINTY  expressions typed by  the
        user, evaluates them  in the  context of the  place in  the program  where
        execution was suspended.  The evaluation is performed just as if the  user
        had inserted an  extra statement into  the original program  at the  point
        where execution was suspended.   The user may ask  to evaluate any  POINTY
        expression whose  evaluation would  be legal  at the  point at  which  the
        execution of the program was suspended.
 
        POINTY prompts the user for input by typing a ⊂:*:⊃.  Input can be  edited
        using the standard line editor.  The activation character is the semicolon
        or the carriage return, whathever comes first.
 
        The POINTY  instructions  typed are  numbered  starting from  1,  so  that
        reference  to  an  instruction  can   be  done  through  its  number,   or
        referred to as coordinate.
 
 
        --------------------------------------------------------------------------
        Here is the list of instructions available ONLY in debug mode:
        --------------------------------------------------------------------------
 
                BREAK(COORD)
                BREAK("PROCEDURE_NAME", COORD)
        Put a breakpoint at the specified point. 
 
                HALT
        Send the control to the 10.
 
                TEXT
                TEXT(MIN#)
                TEXT(MIN#,MAX#)
                TEXT("PROCEDURE_NAME",MIN#)
                TEXT("PROCEDURE_NAME",MIN#,MAX#)
        Show the source text,  from MIN# to MAX#.  If MAX# < MIN#  set MAX# to  be
        MIN#+MAX#. If MAX#  is omitted  set it  to be  MIN#. If  both numbers  are
        omitted show the next instruction to be executed.
        
                RESTART                                            
        Restart the program from the beginning.   Can be called only when  outside
        from procedures.
 
                TRAPS
        Show the exixting breakpoints.
 
                UNBREAK(COORD)
                UNBREAK("PROCEDURE_NAME", COORD)
        Remove a breakpoint from  the specified point.  Complain if no  breakpoint
        has been set.
 
                !!GO, <CONTROL>G
        Continue the execution, from the point where it was suspended.
 
                !!STEP, <CONTROL>S
        Execute next statement and stop after that.
 
                !!GSTEP, <CONTROL>X
        Execute next statement, considering compound statement or procedure  calls
        as a single statement, and stops after that.
 
        --------------------------------------------------------------------------
        KNOWN BUGS
        --------------------------------------------------------------------------
 
        TRAPS shows the breakpoints in the main program and in untyped  procedures
        (doesn't work yet for typed procedures)
 
        COBEGIN/COEND cause severe problems. Don't try it!
        \∃

∀\145\SYSTEM\building up a new POINTY system\∃

∀\146\SYS10\building up system on the PDP-10\∃

∀\147\\        The system on the PDP-10 part can be built up
        easily
        by means of the instruction "DO PCOMP[PNT,HE]".  This DO file does
        deletes all the .REL files which are no longer valid, rewrites
        INTOPS.SAI, and then proceeds to compile each of the files in the
        POINTY system separately.  It then loads the files and writes
        out the PDP-10 part of the POINTY system as PONTY0.
        ***** CAUTION ****** This is given only as a matter of information.
        Don't fool around with all these unless you are one of the people
        working with the system.\∃

∀\148\SYS11\building up the POINTY runtime system\∃

∀\149\\        There are four parts to the RUNTIME system and
        generally two parts have to be reassembled.  Reassamble POINTY.PAL
        and PNTARM.PAL on [PNT,HE], and these files will automatically call
        in AL.PAL and ARM.PAL respectively.  Then to load up the 11 and
        get a .SAV file do the following:
 
                .A ARM
                .R 11TTY
                *Z500000
                *LPOINTY[PNT,HE]
                *OPNTARM[PNT,HE]
                *OK1[11,SYS]
                *OPNTY[PNT,HE]
                *W160000
                *1
                *ATERM
                *VT05
                *SD     <now on the VT05 type <alt>G and wait for scanning>
                *ATOP
                *500000
                *DPOINTY
                *X
                .
        ***** CAUTION ****** This is given only as a matter of information.
        Don't fool around with all these unless you are one of the people
        working with the system.\∃

∀\150\SYSALL\describes building up the POINTY system\∃

∀\151\\        The part on the 10 and the runtime must first be
        built up, as described in SYS10 and SYS11.  Then do the following:
 
                .A ARM
                .R 11TTY
                *GPOINTY[PNT,HE]
                *X
                .RU PONTY0[PNT,HE]
 
        When everything is working fine, type the instruction
                SAVECOREIMAGE P0
 
        The coreimage of both the parser on the 10 and the runtime system
        on the the 11 will be saved in a file named P0.  To resume the
        execution at a later date, type RU P0.  If you want to get at this
        file by means of R POINTY, then rename this file POINTY.DMP[PNT,HE]
        by means of the RENAME command as follows:
                RENAME POINTY.DMP[PNT,HE]←P0.DMP
        ***** CAUTION ****** This is given only as a matter of information.
        Don't fool around with all these unless you are one of the people
        working with the system.\∃

∀\152\\\∃